home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1999 July: Technology Seed / ADC Seed CD - July 1999.toast / Carbon SDK 1.0d10c3 / Sample Code / SimpleText / Clipboard.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-05-04  |  14.6 KB  |  552 lines  |  [TEXT/CWIE]
  1. /*
  2.     File:        Clipboard.c
  3.  
  4.     Contains:    Clipboard support for simple text application.
  5.  
  6.     Version:    SimpleText 1.4 or later
  7.  
  8.     Written by:    Tom Dowdy
  9.                 DAL = Dave Lyons
  10.  
  11.     Copyright:    © 1993-1997 by Apple Computer, Inc., all rights reserved.
  12.  
  13.     File Ownership:
  14.  
  15.         DRI:                Tom Dowdy
  16.  
  17.         Other Contact:        Jim Negrette
  18.  
  19.         Technology:            Macinotosh Graphics Group
  20.  
  21.     Writers:
  22.  
  23.         (dmp)    Dave Polaschek
  24.         (ted)    Tom Dowdy
  25.         (TD)    Tom Dowdy
  26.  
  27.     Change History (most recent first):
  28.  
  29.     $Log: Clipboard.c,v $
  30.     Revision 1.10  1999/05/01 01:52:24  jiarocci
  31.     Comment out grafprocs so we build against latest CarbonLib interfaces on 8.x.
  32.  
  33.     Revision 1.9  1999/02/16 00:41:37  christ
  34.     Integrate document proxy icon support
  35.  
  36.     Revision 1.8  1998/11/11 22:28:52  wilkes
  37.     Fixed various problems caused by the interface changes made by Nitin earlier,
  38.     mostly involving static RoutineDescriptors...
  39.     
  40.     Revision 1.7  1998/10/14 18:52:45  voas
  41.     Eliminate all warnings. Get working with top of tree.
  42.  
  43.     Revision 1.6  1998/09/15 18:59:42  jiarocci
  44.     SimpleText now builds with -DTARGET_CARBON=1. Still needs further cleanup.
  45.     
  46.     Revision 1.5  1998/09/12 23:07:57  voas
  47.     Use InvalWindowRect instead of InvalRect.
  48.  
  49.     Revision 1.4  1998/03/30 22:12:24  mkellner
  50.     Update to use new GetQDxxxx macros for qd.globals
  51.     
  52.     Revision 1.3  1998/03/21 04:13:11  mkellner
  53.     Add a define for qd_screenBits for qd.screenBits.
  54.     Replaced qd.screenBits with qd_screenBits
  55.     
  56.     Revision 1.2  1998/03/20 03:19:52  mkellner
  57.     change qd.thePort to FrontWindow()
  58.     add SysEnvirons
  59.     
  60.     Revision 1.1.1.1  1998/03/18 22:56:06  ivory
  61.     Initial checkin of SimpleText.
  62.     
  63.         
  64.         2     7/29/97 2:07 PM Tom Dowdy
  65.         Removed all of the old and boring refs
  66.         
  67.         1     7/28/97 11:11 AM Duane Byram
  68.         first added to Source Safe project
  69.  
  70.          <5>      9/9/96    dmp        staticfy local functions to eliminate warnings in MWC.
  71.          <4>     5/31/96    ted        spelling FAT correctly
  72.          <4>     5/31/96    ted        adding PPC, FAT, and NuKernel builds
  73.          <3>     11/2/95    ted        BlockMoveData
  74.          <2>     10/2/95    TD        adding support for SC compiler
  75.          <1>     8/21/95    TD        First checked in.
  76.          <8>      9/8/94    DAL        Added do-nothing routines ClipboardKeyEvent and
  77.                                     ClipboardGetBalloon, to avoid strange balloon & keypress message
  78.                                     for the Clipboard window.
  79.  
  80. */
  81.  
  82. #include "MacIncludes.h"
  83.  
  84. #include "Clipboard.h"
  85.  
  86.  
  87. // --------------------------------------------------------------------------------------------------------------
  88. // GLOBALS FOR THIS FILE ONLY
  89. // --------------------------------------------------------------------------------------------------------------
  90. static Handle            gScrapHandle;
  91. static long            gCurrentOffset;
  92. #if USE_QD_GRAFPROCS
  93. static CQDProcs            gSavedProcs;
  94. static CQDProcs                gMyProcs;
  95. static CQDProcs                gMyColorProcs;
  96. #endif
  97.  
  98. // --------------------------------------------------------------------------------------------------------------
  99. // INTERNAL ROUTINES
  100. // --------------------------------------------------------------------------------------------------------------
  101. static pascal void GetPICTData(Ptr dataPtr, short byteCount)
  102. /*
  103.     replacement for the QuickDraw bottleneck routine
  104. */
  105. { 
  106.     long    longCount = byteCount;
  107.     
  108.     BlockMoveData((*gScrapHandle)+gCurrentOffset, dataPtr, longCount);
  109.     gCurrentOffset += longCount;
  110.     
  111. } // GetPICTData
  112.  
  113.  
  114. // --------------------------------------------------------------------------------------------------------------
  115.  
  116. static OSErr DrawPictureFromHandleAndOffset(
  117.     Rect    * pWhereToDraw,            // draw picture at this location
  118.     Handle    sourceHandle,            // handle containing data
  119.     long    sourceOffset)            // offset within handle to start at
  120. {
  121.     static QDGetPicUPP gGetPICTData = NULL;
  122.     OSErr        anErr;
  123.     Rect        whereToDraw = *pWhereToDraw;
  124.     PicHandle    tempPict = (PicHandle) NewHandle(sizeof(Picture));
  125. #if USE_QD_GRAFPROCS
  126.     CGrafPtr    thePort = GetQDGlobalsThePort();
  127. #endif
  128.  
  129.     if (!gGetPICTData) {
  130.         gGetPICTData = NewQDGetPicProc(GetPICTData);
  131.     }
  132.     
  133.     anErr = MemError();
  134.     nrequire(anErr, FailedNewHandle);
  135.         
  136.     // calculate the rectangle in which to draw, save the picture header into
  137.     // our handle
  138.     {    
  139.     PicPtr    pPicture;
  140.     
  141.     pPicture = (PicPtr)((*sourceHandle) + sourceOffset);
  142.     whereToDraw.right = whereToDraw.left + pPicture->picFrame.right - pPicture->picFrame.left;
  143.     whereToDraw.bottom = whereToDraw.top + pPicture->picFrame.bottom - pPicture->picFrame.top;
  144.     BlockMoveData((Ptr)pPicture, (Ptr)*tempPict, sizeof(Picture));
  145.     }
  146.  
  147.     // store into globals for our GetPicProc in preparation for the draw
  148.     gScrapHandle = sourceHandle;
  149.     gCurrentOffset = sourceOffset + sizeof(Picture);
  150.  
  151. #if USE_QD_GRAFPROCS
  152.     // install our GetPic proc
  153.     SetStdCProcs(&gMyColorProcs);
  154.     gMyProcs.getPicProc = gGetPICTData;
  155.     gMyColorProcs.getPicProc = gGetPICTData;
  156.     GetPortGrafProcs(thePort, &gSavedProcs);
  157.     SetPortGrafProcs(thePort, &gMyColorProcs);
  158. #endif
  159.     
  160.     // Draw the picture
  161.     DrawPicture(tempPict, &whereToDraw);
  162.     
  163. #if USE_QD_GRAFPROCS
  164.     // remove our GetPic proc
  165.     GetPortGrafProcs(thePort, &gSavedProcs);
  166. #endif
  167.  
  168.     DisposeHandle((Handle)tempPict);
  169.     
  170. // FALL THROUGH EXCEPTION HANDLING
  171. FailedNewHandle:
  172.     return anErr;
  173.     
  174. } // DrawPictureFromHandleAndOffset
  175.  
  176.  
  177. //
  178. // Figure out the scrap type and offset
  179. //
  180. static long GetScrapTypeAndOffset( OSType * type, long * offset )
  181. {
  182.     short         i = 0;
  183.     ResType        scrapTypes[] = {'TEXT', 'PICT', '????'};
  184.     long        scrapResult = 0;
  185.  
  186.     while (scrapTypes[i] != '????')
  187.         {
  188.         scrapResult = GetScrap(nil, scrapTypes[i], offset);
  189.         if (scrapResult > 0)
  190.             {
  191.             *type = scrapTypes[i];
  192.             break;
  193.             }
  194.         ++i;
  195.         }
  196.     
  197.     return scrapResult;
  198. }
  199.  
  200. // --------------------------------------------------------------------------------------------------------------
  201. // OOP INTERFACE ROUTINES
  202. // --------------------------------------------------------------------------------------------------------------
  203. static OSErr    ClipboardUpdateWindow(WindowRef pWindow, WindowDataPtr pData)
  204. {
  205. #pragma unused (pData)
  206.  
  207.     OSErr        anErr;
  208.     FontInfo    theInfo;
  209.     long        scrapResult = 0;
  210.     long        offset;
  211.     ResType        validScrapType = '????';
  212.     Rect        topAreaRect;
  213.     Rect        bounds;
  214.     RgnHandle    oldClip = NewRgn();
  215.     Rect        eraseRect;
  216.     
  217.     GetWindowPortBounds( pWindow, &eraseRect );
  218.     
  219.     // clear out any data that was there before
  220.     GetClip(oldClip);
  221.     EraseRect(GetWindowPortBounds(pWindow, &bounds));
  222.     
  223.     // get that scrap!
  224.     anErr = LoadScrap();
  225.     nrequire(anErr, LoadScrap);
  226.     
  227.     // figure out the scrap type and offset
  228.     scrapResult = GetScrapTypeAndOffset( &validScrapType, &offset );
  229.     
  230.     // setup for the drawing
  231.     TextFont(applFont);
  232.     TextSize(9);
  233.     GetFontInfo(&theInfo);
  234.  
  235.     // caclulate our area at the top to say what type of contents the scrap is
  236.         GetWindowPortBounds(pWindow, &topAreaRect);
  237.     topAreaRect.bottom = topAreaRect.top + theInfo.ascent + theInfo.descent + theInfo.leading * 2 + 2;
  238.  
  239.     if( gMachineInfo.haveAppearanceMgr )
  240.         {
  241.         // draw a Finder-style window header
  242.         Rect placardRect = topAreaRect;
  243.         
  244.         InsetRect( &placardRect, -1, -1 );
  245.         
  246.         DrawThemePlacard( &placardRect, IsWindowHilited(pWindow) ? kThemeStateActive : kThemeStateInactive );
  247.         eraseRect.top = placardRect.bottom + 1;
  248.         }
  249.     else
  250.         {
  251.     // draw two lines under the area to separate it from the rest of the window
  252.     MoveTo(topAreaRect.left, topAreaRect.bottom - 2);
  253.     Line(topAreaRect.right - topAreaRect.left, 0);
  254.     Move(0, 2);
  255.     Line(-(topAreaRect.right - topAreaRect.left), 0);
  256.         }
  257.     
  258.     EraseRect( &eraseRect );
  259.  
  260.     // draw a string describing the contents
  261.     {
  262.     Str255    theString;
  263.     
  264.     switch (validScrapType)
  265.         {
  266.         case 'PICT':
  267.             GetIndString(theString, kClipboardStrings, iClipboardPICT);
  268.             break;
  269.             
  270.         case 'TEXT':
  271.             GetIndString(theString, kClipboardStrings, iClipboardText);
  272.             break;
  273.             
  274.         default:
  275.             if (InfoScrap()->scrapCount == 0)
  276.                 GetIndString(theString, kClipboardStrings, iClipboardNone);
  277.             else
  278.                 GetIndString(theString, kClipboardStrings, iClipboardUnknown);
  279.             break;
  280.         }
  281.         
  282.     MoveTo(topAreaRect.left + 4, topAreaRect.bottom - 4);
  283.  
  284.     // draw in the correct placard text color ••• need to add deviceloop
  285.     if( gMachineInfo.haveAppearanceMgr )
  286.         {
  287.         ThemeTextColor    themeTextColor = kThemeTextColorPlacardActive;
  288.     
  289.         if( ! IsWindowHilited(pWindow) )
  290.             {
  291.             themeTextColor = kThemeTextColorPlacardInactive;
  292.             }
  293.         
  294.         SetThemeTextColor( themeTextColor, 32, true );
  295.         }
  296.     
  297.     DrawString(theString);
  298.     }
  299.     
  300.     // calculate the part *not* in our top area    
  301.     topAreaRect.top = topAreaRect.bottom+1;
  302.         topAreaRect.bottom = GetWindowPortBounds(pWindow, &bounds)->bottom;
  303.  
  304.     // remember the scrap count -- if it changes, we do an update!
  305.     ((ClipboardDataPtr)pData)->scrapCount = InfoScrap()->scrapCount;
  306.  
  307.     // now, draw the contents, if we have a legal type to use
  308.     {
  309.     Rect    clipArea = topAreaRect;
  310.     Handle    scrapHandle = InfoScrap()->scrapHandle;
  311.     
  312.     // scrollbar clear area - Donna doesn’t like this.  She’s right- we have no scrollbars!
  313. //    clipArea.right -= 15;
  314. //    clipArea.bottom -= 15;
  315.     ClipRect(&clipArea);
  316.     switch (validScrapType)
  317.         {
  318.         case 'PICT':
  319.             DrawPictureFromHandleAndOffset(&clipArea, 
  320.                     scrapHandle, offset);
  321.             break;
  322.             
  323.         case 'TEXT':
  324.             {
  325.             char    oldState;
  326.                     
  327.             oldState = HGetState(scrapHandle);
  328.             HLock(scrapHandle);
  329.             clipArea.right -= 15;
  330.             clipArea.bottom -= 15;
  331.             TETextBox(*scrapHandle+offset, scrapResult, &clipArea, teJustLeft);
  332.             }
  333.             break;
  334.         }
  335.     }
  336.     
  337.     // finally draw the grow icon, but omit our top area rect from the drawing
  338.     ClipRect(&topAreaRect);
  339.     DrawGrowIcon(pWindow);
  340.     
  341.     SetClip(oldClip);
  342.     DisposeRgn(oldClip);
  343.     
  344.     UnloadScrap();
  345.     
  346. // FALL THROUGH EXCEPTION HANDLING
  347. LoadScrap:
  348.     return anErr;
  349.     
  350. } // ClipboardUpdateWindow
  351.  
  352.  
  353. // --------------------------------------------------------------------------------------------------------------
  354.  
  355. static Boolean    ClipboardFilterEvent(WindowPtr pWindow, WindowDataPtr pData, EventRecord *pEvent)
  356. {    
  357.  
  358.     // Force an update on scrap changes during activate/deactivate.
  359.  
  360.     switch (pEvent->what)
  361.         {
  362.         case nullEvent:
  363.             if (LoadScrap() == noErr)
  364.             {
  365.             PScrapStuff pScrap = InfoScrap();
  366.  
  367.             if (pScrap->scrapCount != ((ClipboardDataPtr)pData)->scrapCount)
  368.                 {
  369.                 Rect bounds;
  370.                 InvalWindowRect(pWindow, GetWindowPortBounds(pWindow, &bounds));
  371.                 }
  372.             }
  373.             break;
  374.             
  375.         case activateEvt:
  376.                 {
  377.                 Rect bounds;
  378.                 InvalWindowRect(pWindow, GetWindowPortBounds(pWindow, &bounds));
  379.                 }
  380.             break;
  381.         
  382.         // Follow the HI guidelines and hide the clipboard when we are suspended.
  383.     
  384.         case osEvt:
  385.             if (((pEvent->message >> 24) & 0x0FF) == suspendResumeMessage)
  386.                 {
  387.                 if((pEvent->message & resumeFlag)==0)    // suspending
  388.                     {
  389.                     HideWindow(pWindow);
  390.                     pWindow = FrontWindow();
  391.                     if (pWindow)
  392.                         HiliteWindow(pWindow, false);
  393.                     }
  394.                 else                                    // resuming
  395.                     ShowWindow(pWindow);
  396.                 }
  397.             break;
  398.             
  399.         } // switch(what)
  400.     
  401.     return false;
  402.     
  403. } // ClipboardFilterEvent
  404.  
  405.  
  406. // --------------------------------------------------------------------------------------------------------------
  407.  
  408. static OSErr    ClipboardKeyEvent(WindowPtr pWindow, WindowDataPtr pData, EventRecord *pEvent, Boolean isMotionKey)
  409. {    
  410.     #pragma unused(pWindow, pData, pEvent, isMotionKey)
  411.  
  412.     return noErr;
  413.  
  414. } // ClipboardKeyEvent
  415.  
  416.  
  417. // --------------------------------------------------------------------------------------------------------------
  418.  
  419. static OSErr    ClipboardGetBalloon(WindowPtr pWindow, WindowDataPtr pData, 
  420.         Point *localMouse, short * returnedBalloonIndex, Rect *returnedRectangle)
  421. {
  422. #pragma unused (pWindow, pData, localMouse, returnedRectangle)
  423.  
  424.     *returnedBalloonIndex = iNoBalloon;
  425.     
  426.     return noErr;
  427.  
  428. } // ClipboardGetBalloon
  429.  
  430. // --------------------------------------------------------------------------------------------------------------
  431.  
  432. static OSErr    ClipboardGetDocumentRect(WindowPtr pWindow, WindowDataPtr pData, 
  433.             LongRect * documentRectangle, Boolean forGrow)
  434. {
  435. #pragma unused (pWindow, pData, forGrow)
  436.     
  437.     OSType    scrapType = 0;
  438.     long    sourceOffset;
  439.     Rect    theMaxSize;
  440.     
  441.     // default to size of main screen (••• sucks for text)
  442.     GetPixBounds( (**GetMainDevice()).gdPMap, &theMaxSize );
  443.     
  444.     GetScrapTypeAndOffset( &scrapType, &sourceOffset );
  445.     
  446.     //
  447.     // We know the size of a picture, man.
  448.     //
  449.     if( scrapType == 'PICT' )
  450.     {
  451.         if( LoadScrap() == noErr )
  452.         {
  453.             Handle        sourceHandle = InfoScrap()->scrapHandle;
  454.             PicPtr        pPicture;
  455.             FontInfo    theInfo;
  456.         
  457.             pPicture = (PicPtr)((*sourceHandle) + sourceOffset);
  458.             theMaxSize.right = pPicture->picFrame.right - pPicture->picFrame.left;
  459.             theMaxSize.bottom = pPicture->picFrame.bottom - pPicture->picFrame.top;
  460.             
  461.             //
  462.             // add window header size
  463.             //
  464.             TextFont(applFont);
  465.             TextSize(9);
  466.             GetFontInfo( &theInfo );
  467.             
  468.             theMaxSize.bottom += theInfo.ascent + theInfo.descent + theInfo.leading * 2 + 2;
  469.             
  470.             //
  471.             // add width for scrollbars (••• which don’t exist)
  472.             //
  473. //            theMaxSize.bottom += 15;
  474. //            theMaxSize.right += 15;
  475.             
  476.             UnloadScrap();
  477.         }
  478.  
  479.     }
  480.  
  481.     RectToLongRect(&theMaxSize, documentRectangle);
  482.     
  483.     return noErr;
  484.     
  485. } // ClipboardGetDocumentRect
  486.  
  487.  
  488. // --------------------------------------------------------------------------------------------------------------
  489.  
  490. static OSErr    ClipboardCloseWindow(WindowPtr pWindow, void* refCon)
  491. {    
  492. #pragma unused(pWindow,refCon)
  493.  
  494.     ChangeCommandName(cShowClipboard, kClipboardStrings, iClipboardShow);
  495.     UnloadScrap();
  496.     
  497.     return noErr;
  498.  
  499. } // ClipboardCloseWindow
  500.  
  501.  
  502. // --------------------------------------------------------------------------------------------------------------
  503.  
  504. static OSErr    ClipboardMakeWindow(WindowPtr pWindow, WindowDataPtr pData)
  505. {
  506. #pragma unused (pWindow)
  507.     BitMap bitmap;
  508.  
  509.     pData->hasGrow                 = true;
  510.     pData->pFilterEvent         = (FilterEventProc)     ClipboardFilterEvent;
  511.     pData->pKeyEvent            = (KeyEventProc)         ClipboardKeyEvent;
  512.     pData->pGetBalloon            = (GetBalloonProc)         ClipboardGetBalloon;
  513.     pData->pUpdateWindow         = (UpdateWindowProc)     ClipboardUpdateWindow;
  514.     pData->pGetDocumentRect     = (GetDocumentRectProc) ClipboardGetDocumentRect;
  515.     pData->pCloseWindow            = (CloseWindowProc)        ClipboardCloseWindow;
  516.     
  517.     GetQDGlobalsScreenBits(&bitmap);
  518.     pData->contentRect.right = pData->contentRect.left + 
  519.                     bitmap.bounds.right - 
  520.                     bitmap.bounds.left - 96;
  521.     pData->contentRect.bottom = pData->contentRect.top + 150;
  522.     MoveWindow(pWindow, bitmap.bounds.left + 4, 
  523.             bitmap.bounds.bottom - 154, false);
  524.     
  525.     ChangeCommandName(cShowClipboard, kClipboardStrings, iClipboardHide);
  526.  
  527.     return noErr;
  528.     
  529. } // ClipboardMakeWindow
  530.  
  531.  
  532. // --------------------------------------------------------------------------------------------------------------
  533.  
  534. OSErr    ClipboardPreflightWindow(PreflightPtr pPreflightData)
  535. {    
  536.     pPreflightData->resourceID            = kClipboardWindowID;
  537.     pPreflightData->continueWithOpen     = true;
  538.     pPreflightData->makeProcPtr         = ClipboardMakeWindow;
  539.     pPreflightData->storageSize         = sizeof(ClipboardDataRecord);
  540.     
  541.     return noErr;
  542.     
  543. } // ClipboardPreflightWindow
  544.  
  545. // --------------------------------------------------------------------------------------------------------------
  546.  
  547. void ClipboardGetFileTypes(OSType * pFileTypes, OSType * pDocumentTypes, short * numTypes)
  548. {
  549. #pragma unused (pFileTypes, pDocumentTypes, numTypes)
  550.  
  551. } // ClipboardGetFileTypes
  552.